/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package motoressa;

import Persistencia.ControladoraPersistencia;
import Persistencia.exceptions.NonexistentEntityException;
import Persistencia.exceptions.PreexistingEntityException;
import Visual.MenuPrincipal;
import java.util.Calendar;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;


public class MotoresSA {

ControladoraPersistencia miPersistencia= new ControladoraPersistencia();
    
private List<Marca> misMarcas= miPersistencia.dameMisMarcas(); 
private List<Administrativo> misAdministrativos= miPersistencia.dameMisAdministrativos();
private List<Calle> misCalles= miPersistencia.dameMisCalles();
private List<Cliente> misClientes= miPersistencia.dameMisClientes();
private List<DetalleDePedido> misDetallesDePedidos= miPersistencia.dameMisDetallesDePedido();
private List<Egreso> misEgresos= miPersistencia.dameMisEgresos();
private List<Empleado> misEmpleados= miPersistencia.dameMisEmpleados();
private List<EncabezadoDePedido> misEncabezadosDePedidos= miPersistencia.dameMisEncabezadosDePedidos();
private List<Especialidad> misEspecialidades= miPersistencia.dameMisEspecialidad();
private List<Estado> misEstados= miPersistencia.dameMisEstado();
private List<GrupoDeConstruccion> misGruposDeCostruciones= miPersistencia.dameMisGruposDeConstruccion();
private List<InformeDeDiagnostico> misInformesDeDiagnosticos= miPersistencia.dameMisInformeDeDiagnostico();
private List<Ingreso> misIngresos= miPersistencia.dameMisIngresos();
private List<Localidad> misLocalidades= miPersistencia.dameMisLocalidades();
private List<Operacion> misOperaciones= miPersistencia.dameMisOperaciones();
private List<OrdenDeReparacion> misOrdenesDeReparacion= miPersistencia.dameMisOrdenesDeReparaciones();
private List<Persona> misPersonas= miPersistencia.dameMisPersonas();
private List<Proveedor> misProveedores= miPersistencia.dameMisProveedores();
private List<Repuesto> misRepuestos= miPersistencia.dameMisRepuestos();
private List<Segmento> misSegmentos= miPersistencia.dameMisSegmentos();
private List<Servicio> misServicios= miPersistencia.dameMisServicios();
private List<Stock> misStock= miPersistencia.dameMisStock();
private List<Sucursal> misSucursales= miPersistencia.dameMisSucursales();
private List<Taller> misTalleres= miPersistencia.dameMisTalleres();
private List<Tecnico> misTecnicos= miPersistencia.dameMisTecnicos();
private List<TipoDeServicio> misTiposDeServicios= miPersistencia.dameMisTiposDeServicios();
private List<TipoPedido> misTiposPedidos= miPersistencia.dameMisTiposPedidos();
private List<Turno> misTurnos= miPersistencia.dameMisTurnos();
private List<Vehiculo> misVehiculos= miPersistencia.dameMisVehiculos();
private List<Zona> misZonas= miPersistencia.dameMisZonas();
private List<Modelo> misModelos= miPersistencia.dameMisMOdelos();

//Clase Calle

public void agregarCalle(int codigo,String Nombre) throws PreexistingEntityException, Exception{
    Calle miCalle=new Calle(codigo, Nombre); //ACA GENERO UNA NUEVA INSTANCIA
    this.misCalles.add(miCalle); // ACA AGREGO LA NUEVA INSTANCIA A LA LISTA QUE CONTIENE TODAS LAS CALLES
    miPersistencia.agregarCalle(miCalle); //ACA GUARDO EN LA BASE DE DATOS LA NUUEVA INSTANCIA
}
public void editarCalle(String Nombre,Localidad miLocalidad) throws NonexistentEntityException, Exception{  
Calle miCalle= this.dameMiCalle(miLocalidad, Nombre);
miCalle.setNombreCalle(Nombre);
this.miPersistencia.editarCalle(miCalle);
}

public Calle dameMiCalle(Localidad miLocalidad,String Nombre){
    Calle miCalleRetorno = null;
    for (Calle unaCalle:miLocalidad.getMisCalles()){
        if(unaCalle.getNombreCalle().equals(Nombre)){
            miCalleRetorno=unaCalle;
        }
    }
    return miCalleRetorno;
}
public List<Calle> dameMisCalles(){
    return this.misCalles;
}

///////////////////CLASE ADMINISTRATIVOS
public void agregarAdministrativo(String cuil, String nombreApellido, String dni, Localidad miLocalidad, Calle miCalles, String numeroTelefono, int numeroCalle) throws PreexistingEntityException, Exception{
    Administrativo miAdministrativo = new Administrativo(cuil, nombreApellido, dni, miLocalidad, miCalles, numeroTelefono, numeroCalle);
    this.misAdministrativos.add(miAdministrativo);
    miPersistencia.agregarAdministrativo(miAdministrativo);
}
public void editarAdministrativo(String cuil, String nombreApellido, String dni, String numeroTelefono, int numeroCalle) throws NonexistentEntityException, Exception{     
Administrativo miAdministrativo= this.dameMiAdministrativo(cuil);
miAdministrativo.setCuil(cuil);
miAdministrativo.setDni(dni);
miAdministrativo.setNombreApellido(nombreApellido);
miAdministrativo.setNumeroTelefono(numeroTelefono);
miAdministrativo.setNumeroCalle(numeroCalle);
this.miPersistencia.editarAdministrativo(miAdministrativo);
}
public Administrativo dameMiAdministrativo(String dni){
    Administrativo miAdministrativoRetorno = null;
    for (Administrativo unAdministrativo:this.misAdministrativos){
        if(unAdministrativo.getDni().equals(dni)){
            miAdministrativoRetorno=unAdministrativo;
        }
    }
    return miAdministrativoRetorno;
}
public List<Administrativo> dameMisAdministrativos(){
    return this.misAdministrativos;
}

//////////////CLASE CLIENTE/////////////

public void agregarCliente(String nombreApellido,String dni, String miCalles, String numeroTelefono, int numeroCalle, String Cuit,String unaLocalidad) throws PreexistingEntityException, Exception{
List<Vehiculo> vehiculoCliente= new LinkedList();
List<EncabezadoDePedido> EncabezadoCliente= new LinkedList();
List<Turno> ClienteTurno=new LinkedList();
Localidad miLocalidad=dameMiLocalidad(unaLocalidad);
Calle miCalle=dameMiCalle(miLocalidad,miCalles);
Cliente miCliente = new Cliente( Cuit,EncabezadoCliente, vehiculoCliente,ClienteTurno,nombreApellido,dni,miLocalidad, miCalle, numeroTelefono,numeroCalle);
this.misClientes.add(miCliente);
miPersistencia.agregarCliente(miCliente);
}
public List<Cliente> dameMisClientes(){
    return this.misClientes;
}
public void editarCliente(String nombreApellido,String dni, Calle miCalles, String numeroTelefono, int numeroCalle, String Cuit,Localidad unaLocalidad) throws NonexistentEntityException, Exception{
Cliente miCliente = this.dameMiCliente(dni);
miCliente.setCuit(Cuit);
miCliente.setDni(dni);
miCliente.setMiCalles(miCalles);
miCliente.setMiLocalidad(unaLocalidad);
miCliente.setNumeroCalle(numeroCalle);
miCliente.setNombreApellido(nombreApellido);
miCliente.setNumeroTelefono(numeroTelefono);
this.miPersistencia.editarCliente(miCliente);
}
public Cliente dameMiCliente(String dni){
    Cliente miClienteRetorno = null;
    for(Cliente unCliente:this.misClientes){
        if(unCliente.getDni().equals(dni)){
            miClienteRetorno=unCliente;
        }
    }
    return miClienteRetorno;
}

public Cliente dameMiClienteNombre(String nombre){
    Cliente miCliente=null;
    for(Cliente unCliente:this.misClientes){
        if(unCliente.getNombreApellido().equals(nombre)){
            miCliente=unCliente;
        }
    }
    return miCliente;
}

////////////////CLASE DETALLE DE PEDIDOS
public void agregarDetalleDePedido(int Codigo, int Cantidad, Repuesto miRepuesto) throws PreexistingEntityException, PreexistingEntityException, Exception{
List<DetalleDePedido> MiRepuesto= new LinkedList();
DetalleDePedido miDetalleDePedido = new DetalleDePedido(Codigo, Cantidad, miRepuesto);
this.misDetallesDePedidos.add(miDetalleDePedido);
miPersistencia.agregarDetalleDePedido(miDetalleDePedido);

}
public void editarDetalleDePedido(int Codigo, int Cantidad){
DetalleDePedido miDetalleDePedido = this.dameMiDetalleDePedido(Codigo);
miDetalleDePedido.setCantidad(Cantidad);
}
public DetalleDePedido dameMiDetalleDePedido(int Codigo){
DetalleDePedido miDetalleDePedidoRetorno = null;
    for(DetalleDePedido unDetalleDePedido:this.misDetallesDePedidos){
     if(unDetalleDePedido.getCodigo()==Codigo){
        miDetalleDePedidoRetorno=unDetalleDePedido;
     }
    }
    return miDetalleDePedidoRetorno;
}
public List<DetalleDePedido> dameMisDetallesDePedidos(){
    return this.misDetallesDePedidos;
}

///////////////// CLASE EGRESOS
public void agregarEgreso(int codigo, String descripcion, Calendar fechaEgreso, int kmEgreso, Vehiculo miVehiculo, OrdenDeReparacion miOrdenDeReparacion) throws PreexistingEntityException, Exception{
Egreso miEgreso = new Egreso(codigo, descripcion, fechaEgreso, kmEgreso, miVehiculo, miOrdenDeReparacion);
this.misEgresos.add(miEgreso);
miPersistencia.agregarEgreso(miEgreso);
}
public void editarEgreso(int Codigo, String Descripcion, Calendar fechaEgreso, int kmEgreso){
Egreso miEgreso = this.dameMiEgreso(Codigo);
miEgreso.setDescripcion(Descripcion);
miEgreso.setFechaEgreso(fechaEgreso);
miEgreso.setKmEgreso(kmEgreso);
}
public Egreso dameMiEgreso(int Codigo){
Egreso miEgresoRetorno = null;
    for(Egreso unEgreso:this.misEgresos){
        if(unEgreso.getCodigo()==Codigo){
            miEgresoRetorno=unEgreso;
        }
    }
    return miEgresoRetorno;
}
public List<Egreso> dameMisEgresos(){
    return this.misEgresos;
}

///////////////// CLASE EMPLEADO
public void agregarEmpleado(String cuil, String nombreApellido, String dni, Localidad miLocalidad, Calle miCalles, String numeroTelefono, int numeroCalle) throws PreexistingEntityException, Exception{
Empleado miEmpleado = new Empleado(cuil, nombreApellido, dni, miLocalidad, miCalles, numeroTelefono, numeroCalle);
this.misEmpleados.add(miEmpleado);
miPersistencia.agregarEmpleado(miEmpleado);
}
public void editarEmpleado(String Cuil, String nombreApellido, String dni, String numeroTelefono, int numeroCalle){
Empleado miEmpleado = this.dameMiEmpleado(dni);
miEmpleado.setCuil(Cuil);
miEmpleado.setDni(dni);
miEmpleado.setMiCalles(null);
}
public Empleado dameMiEmpleado(String dni){
Empleado miEmpleadoRetorno = null;
    for(Empleado unEmpleado:this.dameMisEmpleados()){
        if(unEmpleado.getDni().equals(dni)){
            miEmpleadoRetorno=unEmpleado;
        }
    }
    return miEmpleadoRetorno;
}
public List<Empleado> dameMisEmpleados(){
    return this.misEmpleados;
}

/////////////////CLASE ENCABEZADO PEDIDO
public void agregarEncabezadoDePedido(int codigo, int numeroPedido, Calendar fecha, TipoPedido miTipoPedido, Cliente miCliente, Persona miPersona, Proveedor miProveedor, Sucursal miSucursal) throws PreexistingEntityException, Exception{
EncabezadoDePedido miEncabezadoDePedido = new EncabezadoDePedido(codigo, numeroPedido, fecha, miTipoPedido, miCliente, miPersona, miProveedor, miSucursal);
this.misEncabezadosDePedidos.add(miEncabezadoDePedido);
miPersistencia.agregarEncabezadoDePedido(miEncabezadoDePedido);
}
public void editarEncabezadoDePedido(int Codigo, int numeroPedido, Calendar Fecha) throws NonexistentEntityException, NonexistentEntityException, Exception{
EncabezadoDePedido miEncabezadoDePedido = this.DameMiEncabezado(Codigo);
miEncabezadoDePedido.setFecha(Fecha);
miEncabezadoDePedido.setNumeroPedido(numeroPedido);
this.miPersistencia.editarEncabezadoDePedido(miEncabezadoDePedido);
}
public EncabezadoDePedido DameMiEncabezado(int Codigo){
EncabezadoDePedido miEncabezadoDePedidoRetorno = null;
    for(EncabezadoDePedido unEncabezadoDePedido: this.misEncabezadosDePedidos){
        if(unEncabezadoDePedido.getCodigo()==Codigo){
            miEncabezadoDePedidoRetorno = unEncabezadoDePedido;
        }
    }
    return miEncabezadoDePedidoRetorno;
}
public List<EncabezadoDePedido> dameMisEncabezadosDePedidos(){
    return this.misEncabezadosDePedidos;
}

///////////////// CLASE ESPECIALIDAD
public void agregarEspecialidad(int Codigo, String Descripcion) throws PreexistingEntityException, Exception{
Especialidad miEspecialidad = new Especialidad(Codigo, Descripcion);
this.misEspecialidades.add(miEspecialidad);
miPersistencia.agregarEspecialidad(miEspecialidad);
}
public void editarEspecialidad(int Codigo, String Descripcion) throws NonexistentEntityException, Exception{
Especialidad miEspecialidad = this.dameMiEspecialidad(Codigo);
miEspecialidad.setDescripcion(Descripcion);
this.miPersistencia.editarEspecialidad(miEspecialidad);
}
public List<Especialidad> dameMisEspecialidades(){
    return this.misEspecialidades;
}
public Especialidad dameMiEspecialidad(int Codigo){
    Especialidad miEspecialidadRetorno=null;
    for(Especialidad miEspecialidad:this.misEspecialidades){
        if (miEspecialidad.getCodigo()==Codigo){
            miEspecialidadRetorno=miEspecialidad;
        }
    }
    return miEspecialidadRetorno;
}
public Especialidad buscarEspecialidad(String descripcion){
    Especialidad miEspecialidad=null;
    
    for (Especialidad unaEspecialidad:this.misEspecialidades){
        if (unaEspecialidad.getDescripcion().equals(descripcion)){
            miEspecialidad=unaEspecialidad;
        }
    }
    return miEspecialidad;
}
/////////////////CLASE ESTADO
public void agregarEstado(int Codigo, String Descripcion) throws PreexistingEntityException, Exception{
Estado miEstado = new Estado(Codigo, Descripcion);
this.misEstados.add(miEstado);
miPersistencia.agregarEstado(miEstado);
}
public void editarEstado(int Codigo, String Descripcion,String unEstado) throws NonexistentEntityException, NonexistentEntityException, Exception{
Estado miEstado = this.dameMiEstadoNombre(unEstado);
miEstado.setDescripcion(Descripcion);
this.miPersistencia.editarEstado(miEstado);
}

public Estado dameMiEstado(int Codigo){
Estado miEstadoRetorno = null;
    for(Estado miEstado:this.dameMisEstados()){
        if(miEstado.getCodigo()==Codigo){
            miEstadoRetorno=miEstado;
        }
    }
    return miEstadoRetorno;
}

public Estado dameMiEstadoNombre(String nombre){
    Estado miEstadoRetorno=null;
    for(Estado miEstado:this.dameMisEstados()){
        if(miEstado.getDescripcion().equals(nombre)){
            miEstadoRetorno=miEstado;
        }
    }
    return miEstadoRetorno;
}
public List<Estado> dameMisEstados(){
    return this.misEstados;
}

//////////////GRUPOS DE CONSTRUCCION ////////////////////////
public void agregarGrupoDeConstruccion(int codigo, String descripcion, List<Operacion> misOperaciones, List<Repuesto> misRepuestos, Vehiculo miVehiculo) throws PreexistingEntityException, Exception{
GrupoDeConstruccion miGrupoDeConstruccion = new GrupoDeConstruccion(codigo, descripcion, misOperaciones, misRepuestos, miVehiculo);
this.misGruposDeCostruciones.add(miGrupoDeConstruccion);
miPersistencia.agregarGrupoDeConstruccion(miGrupoDeConstruccion);
}
public void editarGrupoDeConstruccion(int Codigo, String Descripcion) throws NonexistentEntityException, Exception{
GrupoDeConstruccion miGrupoDeConstruccion = this.dameMiGrupoDeContruccion(Codigo);
miGrupoDeConstruccion.setDescripcion(Descripcion);
this.miPersistencia.editarGrupoDeConstruccion(miGrupoDeConstruccion);
}
public GrupoDeConstruccion dameMiGrupoDeContruccion(int Codigo){
GrupoDeConstruccion miGrupoDeConstruccionRetorno = null;
    for(GrupoDeConstruccion miGrupoDeConstruccion:this.dameMisGruposDeConstrucciones()){
        if(miGrupoDeConstruccion.getCodigo()== Codigo){
            miGrupoDeConstruccionRetorno = miGrupoDeConstruccion;
        }
    }
    return miGrupoDeConstruccionRetorno;
}
public List<GrupoDeConstruccion> dameMisGruposDeConstrucciones(){
    return this.misGruposDeCostruciones;
}

//////////////CLASE INFORMES DE DIAGNOSTICO /////////////////
public void agregarInformeDeDiagnostico(int codigo, String descripcion, String anomaliasDetectadas, Calendar fechaInforme, Vehiculo miVehiculo, Tecnico miTecnico, OrdenDeReparacion miOrdenDeReparacion) throws PreexistingEntityException, Exception{
InformeDeDiagnostico miInformeDeDiagnostico = new InformeDeDiagnostico(codigo, descripcion, anomaliasDetectadas, fechaInforme, miVehiculo, miTecnico, miOrdenDeReparacion);
this.misInformesDeDiagnosticos.add(miInformeDeDiagnostico);
miPersistencia.agregarInformeDeDiagnostico(miInformeDeDiagnostico);
}
public void editarInformeDeDiagnostico(int codigo, String descripcion, String anomaliasDetectadas, Calendar fechaInforme, Vehiculo miVehiculo, Tecnico miTecnico, OrdenDeReparacion miOrdenDeReparacion) throws NonexistentEntityException, Exception{
InformeDeDiagnostico miInformeDeDiagnostico = this.dameMiInformeDeDiagnostico(codigo);
miInformeDeDiagnostico.setAnomaliasDetectadas(anomaliasDetectadas);
miInformeDeDiagnostico.setDescripcion(descripcion);
miInformeDeDiagnostico.setFechaInforme(fechaInforme);
miInformeDeDiagnostico.setMiOrdenDeReparacion(miOrdenDeReparacion);
miInformeDeDiagnostico.setMiTecnico(miTecnico);
miInformeDeDiagnostico.setMiVehiculo(miVehiculo);
this.miPersistencia.editarInformeDeDiagnostico(miInformeDeDiagnostico);
}       
public InformeDeDiagnostico dameMiInformeDeDiagnostico(int Codigo){
InformeDeDiagnostico miInformeDeDiagnosticoRetorno = null;
    for(InformeDeDiagnostico miInformeDeDiagnostico:this.dameMisInformesDeDiagnosticos()){
        if(miInformeDeDiagnostico.getCodigo()== Codigo){
            miInformeDeDiagnosticoRetorno = miInformeDeDiagnostico;
        }
    }
    return miInformeDeDiagnosticoRetorno;
}

public List<InformeDeDiagnostico> dameMisInformesDeDiagnosticos(){
    return this.misInformesDeDiagnosticos;
}

/////////////////CLASE INGRESO ////////////////////////////
public void agregarIngreso(int codigo, String descripcion, Calendar fechaIngreso, int kmIngreso, Vehiculo miVehiculo, OrdenDeReparacion miOrdenDeReparacion) throws PreexistingEntityException, Exception{
Ingreso miIngreso = new Ingreso(codigo, descripcion, fechaIngreso, kmIngreso, miVehiculo, miOrdenDeReparacion);
this.misIngresos.add(miIngreso);
miPersistencia.agregarIngreso(miIngreso);
}
public void editarIngreso(int codigo, String descripcion, Calendar fechaIngreso, int kmIngreso, Vehiculo miVehiculo, OrdenDeReparacion miOrdenDeReparacion) throws NonexistentEntityException, Exception{
Ingreso miIngreso = this.dameMiIngreso(codigo);
miIngreso.setDescripcion(descripcion);
miIngreso.setFechaIngreso(fechaIngreso);
miIngreso.setKmIngreso(kmIngreso);
miIngreso.setMiOrdenDeReparacion(miOrdenDeReparacion);
miIngreso.setMiVehiculo(miVehiculo);
this.miPersistencia.editarIngreso(miIngreso);
}
public Ingreso dameMiIngreso(int Codigo){
Ingreso miIngresoRetorno = null;
    for(Ingreso miIngreso:this.dameMisIngresos()){
        if(miIngreso.getCodigo()==Codigo){
            miIngresoRetorno = miIngreso;
        }
    }
    return miIngresoRetorno;
}
public List<Ingreso> dameMisIngresos(){
    return this.misIngresos;
}

///////////////////////CLASE LOCALIDAD ///////////////////////////////////
public void agregarLocalidad(int codigo, String nombreLocalidad, List<Calle> misCalles) throws PreexistingEntityException, Exception{
Localidad miLocalidad = new Localidad(codigo, nombreLocalidad, misCalles);
this.misLocalidades.add(miLocalidad);
miPersistencia.agregarLocalidad(miLocalidad);
}
public void editaLocalidad(int codigo, String nombreLocalidad, List<Calle> misCalles){
Localidad miLocalidad = this.dameMiLocalidad(nombreLocalidad);
miLocalidad.setMisCalles(misCalles);
miLocalidad.setNombreLocalidad(nombreLocalidad);
}
public List<Localidad> dameMisLocalidades(){
    return this.misLocalidades;
}
public Localidad dameMiLocalidad(String nombreLocalidad){
    Localidad miLocalidadRetorno = null;
    for (Localidad unaLocalidad:this.misLocalidades){
        if(unaLocalidad.getNombreLocalidad().equals(nombreLocalidad)){
            miLocalidadRetorno=unaLocalidad;
        }
    }
    return miLocalidadRetorno;
}
public Localidad buscarLocalidadNombre(String nombreLocalidad){
    Localidad miLocalidad=null;
    
    for (Localidad unaLocalidad:this.misLocalidades){
        if (unaLocalidad.getNombreLocalidad().equals(nombreLocalidad)){
            miLocalidad=unaLocalidad;
        }
    }
    return miLocalidad;
}
/////////////CLASE MARCAS
public void agregarMarca(int codigo, String descripcion, Vehiculo miVehiculo) throws PreexistingEntityException, Exception{
Marca miMarca = new Marca(codigo, descripcion, miVehiculo);
this.misMarcas.add(miMarca);
miPersistencia.agregarMarca(miMarca);
}
public void editarMarca(int codigo, String descripcion, Vehiculo miVehiculo){
Marca miMarca = this.dameMiMarca(descripcion);
miMarca.setDescripcion(descripcion);
miMarca.setMiVehiculo(miVehiculo);
}
public List<Marca> dameMisMarcas(){
    return this.misMarcas;
}
public Marca dameMiMarca(String Descripcion){
    Marca MiMarcaRetorno = null;
    for (Marca unaMarca:this.misMarcas){
        if(unaMarca.getDescripcion().equals(Descripcion)){
            MiMarcaRetorno=unaMarca;
        }
    }
    return MiMarcaRetorno;
}
///////////////// CLASE MODELOS
public void agregarModelo(int Codigo, String Descripcion, int anio) throws PreexistingEntityException, PreexistingEntityException, Exception{
Modelo miModelo = new Modelo(Codigo, Descripcion, anio);
this.misModelos.add(miModelo);
miPersistencia.agregarModelo(miModelo);
}
public void editarModelo(int Codigo, String Descripcion, int anio){
Modelo miModelo = this.dameMiModelo(Descripcion);
miModelo.setAnio(anio);
miModelo.setDescripcion(Descripcion);
}
public List<Modelo> dameMisModelos(){
    return this.misModelos;
}
public Modelo dameMiModelo(String Descripcion){
    Modelo MiModeloRetorno = null;
    for (Modelo unModelo:this.misModelos){
        if(unModelo.getDescripcion().equals(Descripcion)){
            MiModeloRetorno=unModelo;
        }
    }
    return MiModeloRetorno;
}

////////////////CLASE OPERACIONES
public void agregarOperacion(int codigo, String descripcion, Date tiempo, GrupoDeConstruccion miGrupoDeConstruccion) throws PreexistingEntityException, Exception{
Operacion miOperacion = new Operacion(codigo, descripcion, tiempo, miGrupoDeConstruccion);
this.misOperaciones.add(miOperacion);
miPersistencia.agregarOperacion(miOperacion);
}
public Operacion dameMiOperacion(int Codigo){
    Operacion miOperacionRetorno=null;
    for(Operacion unaOperacion:this.misOperaciones){
        if(unaOperacion.getCodigo()== Codigo){
            miOperacionRetorno=unaOperacion;
        }
    }
    return miOperacionRetorno;
}
public void editarOperacion(int codigo, String descripcion, Date tiempo) throws NonexistentEntityException, Exception {
    Operacion miOperacion=this.dameMiOperacion(codigo);
    miOperacion.setDescripcion(descripcion);
    miOperacion.setTiempo(tiempo);
    this.miPersistencia.editarOperacion(miOperacion);
}
public List<Operacion> dameMisOperaciones(){
    return this.misOperaciones;
}
/////////////////CLASE ORDEN REPARACION
public void agregarOrdenDeReparacion(int codigo, String descripcion, Servicio miServicio, Estado miEstado, Egreso miEgreso, Ingreso miIngreso, GrupoDeConstruccion miGrupoDeConstruccion, Turno miTurno, InformeDeDiagnostico miInformeDeDiagnostico) throws PreexistingEntityException, Exception{
OrdenDeReparacion miOrdenDeReparacion = new OrdenDeReparacion(codigo, descripcion, miServicio, miEstado, miEgreso, miIngreso, miGrupoDeConstruccion, miTurno, miInformeDeDiagnostico);
this.misOrdenesDeReparacion.add(miOrdenDeReparacion);
miPersistencia.agregarOrdenDeReparacion(miOrdenDeReparacion);
}
public void editarOrdenDeReparacion(int codigo, String descripcion, Servicio miServicio, Estado miEstado, Egreso miEgreso, Ingreso miIngreso, GrupoDeConstruccion miGrupoDeConstruccion, Turno miTurno, InformeDeDiagnostico miInformeDeDiagnostico) throws PreexistingEntityException, Exception{
OrdenDeReparacion miOrdenDeReparacion = this.dameMiOrdenDeReparacion(codigo);
miOrdenDeReparacion.setDescripcion(descripcion);

miOrdenDeReparacion.setMiEstado(miEstado);

this.miPersistencia.editarOrdenDeReparacion(miOrdenDeReparacion);
}
public OrdenDeReparacion dameMiOrdenDeReparacion(int Codigo){
OrdenDeReparacion miOrdenDeReparacionRetorno = null;
    for(OrdenDeReparacion unaOrdenDeReparacion:this.misOrdenesDeReparacion){
        if(unaOrdenDeReparacion.getCodigo()== Codigo){
            miOrdenDeReparacionRetorno = unaOrdenDeReparacion;
        }
    }
    return miOrdenDeReparacionRetorno;
}
public List<OrdenDeReparacion> dameMisOrdenDeReparacion(){
    return this.misOrdenesDeReparacion;
}
public void EditarOrden(OrdenDeReparacion miOrden) throws NonexistentEntityException, Exception{
    this.miPersistencia.editarOrdenDeReparacion(miOrden);
}
////////////////CLASE PERSONA
public void agregarPersona(String nombreApellido, String dni, Localidad miLocalidad, Calle miCalles, String numeroTelefono, int numeroCalle) throws PreexistingEntityException, Exception{
Persona miPersona = new Persona(nombreApellido, dni, miLocalidad, miCalles, numeroTelefono, numeroCalle);
this.misPersonas.add(miPersona);
miPersistencia.agregarPersona(miPersona);
}
public void editarPersona(String nombreApellido, String dni, Localidad miLocalidad, Calle miCalles, String numeroTelefono, int numeroCalle) throws PreexistingEntityException, Exception{
Persona miPersona = this.dameMiPersona(dni);
miPersona.setDni(dni);
miPersona.setMiCalles(miCalles);
miPersona.setMiLocalidad(miLocalidad);
miPersona.setNombreApellido(nombreApellido);
miPersona.setNumeroCalle(numeroCalle);
miPersona.setNumeroTelefono(numeroTelefono);
this.miPersistencia.agregarPersona(miPersona);
}
public Persona dameMiPersona(String dni){
Persona miPersonaRetorno = null;
    for(Persona unaPersona:this.misPersonas){
        if(unaPersona.getDni()== dni){
            miPersonaRetorno = unaPersona;
        }
    }
    return miPersonaRetorno;
}
public List<Persona> dameMisPersonas(){
    return this.misPersonas;
}
////////////////CLASE PROVEEDOR
public void agregarProveedor(String cuit, String razonSocial, String emailProveedor, String telefonoProveedor, List<Repuesto> MisRepuestos, Calle miCalle, Localidad miLocalidad) throws PreexistingEntityException, Exception{
Proveedor miProveedor =new Proveedor(cuit, razonSocial, emailProveedor, telefonoProveedor, MisRepuestos, miCalle, miLocalidad);
this.misProveedores.add(miProveedor);
miPersistencia.agregarProveedor(miProveedor);
}
public void editarProveedor(String cuit, String razonSocial, String emailProveedor, String telefonoProveedor, List<Repuesto> MisRepuestos, Calle miCalle, Localidad miLocalidad) throws PreexistingEntityException, Exception{
Proveedor miProveedor = this.dameMiProveedor(cuit);
miProveedor.setCuit(cuit);
miProveedor.setEmailProveedor(emailProveedor);
miProveedor.setMiCalle(miCalle);
miProveedor.setMiLocalidad(miLocalidad);
miProveedor.setMisRepuestos(MisRepuestos);
miProveedor.setRazonSocial(razonSocial);
miProveedor.setTelefonoProveedor(telefonoProveedor);
this.miPersistencia.agregarProveedor(miProveedor);
}
public Proveedor dameMiProveedor(String Cuit){
Proveedor miProveedorRetorno = null;
    for(Proveedor unProveedor:this.misProveedores){
        if(unProveedor.getCuit()== Cuit){
            miProveedorRetorno = unProveedor;
        }
    }
    return miProveedorRetorno;
}
public List<Proveedor> dameMisProveedores(){
    return this.misProveedores;
}
///////////////CLASE REPEUESTOS
public void agregarRepuesto(int codigo, String descripcion, String datosTecnicos, Proveedor miProveedor, DetalleDePedido miDetalleDePedido, GrupoDeConstruccion miGrupoDeConstruccion, Stock miStock) throws PreexistingEntityException, Exception{
Repuesto miRepuesto = new Repuesto(codigo, descripcion, datosTecnicos, miProveedor, miDetalleDePedido, miGrupoDeConstruccion, miStock);
this.misRepuestos.add(miRepuesto);
miPersistencia.agregarRepuesto(miRepuesto);
}
public void editarRepuesto(int codigo, String descripcion, String datosTecnicos, Proveedor miProveedor, DetalleDePedido miDetalleDePedido, GrupoDeConstruccion miGrupoDeConstruccion, Stock miStock) throws PreexistingEntityException, Exception{
Repuesto miRepuesto = this.dameMiRepuesto(codigo);
miRepuesto.setCodigo(codigo);
miRepuesto.setDatosTecnicos(datosTecnicos);
miRepuesto.setDescripcion(descripcion);
miRepuesto.setMiDetalleDePedido(miDetalleDePedido);
miRepuesto.setMiGrupoDeConstruccion(miGrupoDeConstruccion);
miRepuesto.setMiProveedor(miProveedor);
miRepuesto.setMiStock(miStock);
this.miPersistencia.agregarRepuesto(miRepuesto);
}
public Repuesto dameMiRepuesto(int Codigo){
Repuesto miRepuestoRetorno = null;
    for(Repuesto unRepuesto:this.misRepuestos){
        if(unRepuesto.getCodigo() == Codigo){
            miRepuestoRetorno = unRepuesto;
        }
    }
    return miRepuestoRetorno;
}
public List<Repuesto> dameMisRepuetos(){
    return this.misRepuestos;
}
///////// SEGMENTO////////////
public void agregarSegmento(int codigo, String descripcion, List<Vehiculo> misVehiculos) throws PreexistingEntityException, Exception{
Segmento miSegmento = new Segmento(codigo, descripcion, misVehiculos);
this.misSegmentos.add(miSegmento);
miPersistencia.agregarSegmento(miSegmento);
}
public void editarSegmento(int codigo, String descripcion, List<Vehiculo> misVehiculos) throws PreexistingEntityException, Exception{
Segmento miSegmento = this.dameMiSegmento(codigo);
miSegmento.setDescripcion(descripcion);
miSegmento.setMisVehiculos(misVehiculos);
this.miPersistencia.agregarSegmento(miSegmento);
}
public Segmento dameMiSegmento(int Codigo){
Segmento miSegmentoRetorno = null;
    for(Segmento unSegmento:this.misSegmentos){
        if(unSegmento.getCodigo()==Codigo){
            miSegmentoRetorno = unSegmento;
        }
    }
    return miSegmentoRetorno;
}
public List<Segmento> dameMisSegmentos(){
    return this.misSegmentos;
}
///////////SERVICIO///////////////////
public void agregarServicio(int codigo, String descripcion, TipoDeServicio miTipoDeServicio) throws PreexistingEntityException, Exception{
Servicio miServicio = new Servicio (codigo, descripcion, miTipoDeServicio);
this.misServicios.add(miServicio);
miPersistencia.agregarServicio(miServicio);
}
public void editarServicio(int codigo, String descripcion, TipoDeServicio miTipoDeServicio) throws PreexistingEntityException, Exception{
Servicio miServicio = this.dameMiServicio(codigo);
miServicio.setDescripcion(descripcion);
miServicio.setMiTipoDeServicio(miTipoDeServicio);
this.miPersistencia.agregarServicio(miServicio);
}
public Servicio dameMiServicio(int Codigo){
Servicio miServicioRetorno = null;
    for(Servicio unServicio:this.misServicios){
        if(unServicio.getCodigo()== Codigo){
            miServicioRetorno = unServicio;
        }
    }
    return miServicioRetorno;
}
public Servicio dameMiServicio(String Descripcion){
Servicio miServicioRetorno = null;
    for(Servicio unServicio:this.misServicios){
        if(unServicio.getDescripcion().equals(Descripcion)) {
            miServicioRetorno = unServicio;
        }
    }
    return miServicioRetorno;
}
public List<Servicio> dameMisServicios(){
    return this.misServicios;
}
///////////////STOCK/////////////////
public void agregarStock(int codigo, int canidad, String descripcion) throws PreexistingEntityException, Exception{
Stock miStock = new Stock (codigo, canidad, descripcion);
this.misStock.add(miStock);
miPersistencia.agregarStock(miStock);
}
public void editarStock(int codigo, int canidad, String descripcion) throws PreexistingEntityException, Exception{
Stock miStock = this.dameMiStock(codigo);
miStock.setCanidad(canidad);
miStock.setDescripcion(descripcion);
this.miPersistencia.agregarStock(miStock);
}
public Stock dameMiStock(int Codigo){
Stock miStockRetorno = null;
    for(Stock unStock:this.misStock){
        if(unStock.getCodigo()== Codigo){
            miStockRetorno = unStock;
        }
    }
    return miStockRetorno;
}
public List<Stock> dameMisStocks(){
    return this.misStock;
}
////////// CLASE SUCURSALES
public void agregarSucursal(int codigo, String descripcion, String telefonoSucursal, String emailSucursal, Zona miZona, List<Taller> misTalleres) throws PreexistingEntityException, Exception {
    Sucursal miSucursal=new Sucursal(codigo, descripcion, telefonoSucursal, emailSucursal, miZona, misTalleres);
    this.misSucursales.add(miSucursal);
    miPersistencia.agregarSucursal(miSucursal);
}
public Sucursal dameMiSucursal(int codigo){
    Sucursal miSucursalRetorno=null;
    for(Sucursal unaSucursal:this.misSucursales){
        if(unaSucursal.getCodigo()==codigo){
            miSucursalRetorno=unaSucursal;
        }
    }
    return miSucursalRetorno;
}
public void editarSucursal(int codigo, String descripcion, String telefonoSucursal, String emailSucursal, Zona miZona, List<Taller> misTalleres) throws PreexistingEntityException, Exception{
    Sucursal miSucursal=this.dameMiSucursal(codigo);
    miSucursal.setDescripcion(descripcion);
    miSucursal.setEmailSucursal(emailSucursal);
    miSucursal.setMiZona(miZona);
    miSucursal.setMisTalleres(misTalleres);
    miSucursal.setTelefonoSucursal(telefonoSucursal);
    this.miPersistencia.agregarSucursal(miSucursal);
}
public List<Sucursal> dameMisSucursales(){
    return this.misSucursales;
}
public Sucursal buscarSucursal(String descripcion){
    Sucursal miSucursal=null;
    
    for (Sucursal unaSucursal:this.misSucursales){
        if (unaSucursal.getDescripcion().equals(descripcion)){
            miSucursal=unaSucursal;
        }
    }
    return miSucursal;
}
////////// CLASE TALLER
public void agregarTaller(int codigo, String horarioLaboral, List<Turno> misTurnos, List<Tecnico> misTecnicos, List<Servicio> misServicios, Sucursal miSucursal) throws PreexistingEntityException, Exception {
    Taller miTaller=new Taller(codigo, horarioLaboral, misTurnos, misTecnicos, misServicios, miSucursal);
    this.misTalleres.add(miTaller);
    miPersistencia.agregarTaller(miTaller);
}
public Taller dameMiTaller(int codigo){
    Taller miTallerRetorno=null;
    for(Taller unTaller:this.misTalleres){
        if(unTaller.getCodigo()==codigo){
            miTallerRetorno=unTaller;
        }
    }
    return miTallerRetorno;
}

public List<Taller> TallerCliente(String Nombre){
    List<Taller> misTalleres=new LinkedList();
    Cliente miCliente=this.dameMiClienteNombre(Nombre);
    Localidad miLocalidad=miCliente.getMiLocalidad();
    for(Taller miTaller:this.misTalleres){
        if(miTaller.getMiSucursal().getMiZona().getMiLocalidad().getNombreLocalidad().equals(miLocalidad.getNombreLocalidad())){
            misTalleres.add(miTaller);
        }
    }
    return misTalleres;
}
public void editarTaller(int codigo, String horarioLaboral, List<Turno> misTurnos, List<Tecnico> misTecnicos, List<Servicio> misServicios, Sucursal miSucursal) throws PreexistingEntityException, Exception{
    Taller miTaller=this.dameMiTaller(codigo);
    miTaller.setHorarioLaboral(horarioLaboral);
    miTaller.setMiSucursal(miSucursal);
    miTaller.setMisServicios(misServicios);
    miTaller.setMisTecnicos(misTecnicos);
    miTaller.setMisTurnos(misTurnos);
    this.miPersistencia.agregarTaller(miTaller);
}
public List<Taller> dameMisTalleres(){
    return this.misTalleres;
}

////////// CLASE TECNICOS
public void agregarTecnico(int Codigo, Taller miTaller, List<OrdenDeReparacion> misOrdenes, Especialidad miEspecialidad, List<InformeDeDiagnostico> misInformes, String cuil, String nombreApellido, String dni, Localidad miLocalidad, Calle miCalles, String numeroTelefono, int numeroCalle) throws PreexistingEntityException, Exception{
    Tecnico miTecnico=new Tecnico(Codigo, miTaller, misOrdenes, miEspecialidad, misInformes, cuil, nombreApellido, dni, miLocalidad, miCalles, numeroTelefono, numeroCalle);
    this.misTecnicos.add(miTecnico);
    miPersistencia.agregarTecnico(miTecnico);
}
public Tecnico dameMiTecnico(String dni){
    Tecnico miTecnicoRetorno=null;
    for(Tecnico unTecnico:this.misTecnicos){
        if(unTecnico.getDni().equals(dni)){
            miTecnicoRetorno=unTecnico;
        }
    }
    return miTecnicoRetorno;
}
public Tecnico dameMiTecnicoNombre(String NombreApellido){
    Tecnico miTecnicoRetorno=null;
    for(Tecnico unTecnico:this.misTecnicos){
        if(unTecnico.getNombreApellido().equals(NombreApellido)) {
            miTecnicoRetorno=unTecnico;
        }
    }
    return miTecnicoRetorno;
}

public void editarTecnico(int Codigo, Taller miTaller, List<OrdenDeReparacion> misOrdenes, Especialidad miEspecialidad, List<InformeDeDiagnostico> misInformes, String cuil, String nombreApellido, String dni, Localidad miLocalidad, Calle miCalles, String numeroTelefono, int numeroCalle) throws PreexistingEntityException, Exception{
    Tecnico miTecnico=this.dameMiTecnico(dni);
    miTecnico.setCuil(cuil);
    miTecnico.setDni(dni);
    miTecnico.setCodigo(Codigo);
    miTecnico.setMiCalles(miCalles);
    miTecnico.setMiEspecialidad(miEspecialidad);
    miTecnico.setMiLocalidad(miLocalidad);
    miTecnico.setMiTaller(miTaller);
    miTecnico.setMisInformes(misInformes);
    miTecnico.setMisOrdenes(misOrdenes);
    miTecnico.setNombreApellido(nombreApellido);
    miTecnico.setNumeroCalle(numeroCalle);
    miTecnico.setNumeroTelefono(numeroTelefono);
    this.miPersistencia.agregarTecnico(miTecnico);
}
public List<Tecnico> dameMisTecnicos(){
    return this.misTecnicos;
}
////////// CLASE TIPO DE SERVICIO
public void agregarTipoDeServicio(int codigo, String descripcion) throws PreexistingEntityException, PreexistingEntityException, Exception{
    TipoDeServicio miTipoDeServicio = new TipoDeServicio(codigo, descripcion);
    this.misTiposDeServicios.add(miTipoDeServicio);
    miPersistencia.agregarTipoDeServicio(miTipoDeServicio);
}
public TipoDeServicio dameMiTipoDeServicio(int codigo){
    TipoDeServicio miTipoDeServicioRetorno=null;
    for(TipoDeServicio unTipoDeServicio:this.misTiposDeServicios){
        if(unTipoDeServicio.getCodigo()==codigo){
            miTipoDeServicioRetorno=unTipoDeServicio;
        }
    }
    return miTipoDeServicioRetorno;
}
public TipoDeServicio dameMiTipoDeServicio(String Descripcion){
    TipoDeServicio miTipoDeServicioRetorno=null;
    for(TipoDeServicio unTipoDeServicio:this.misTiposDeServicios){
        if(unTipoDeServicio.getDescripcion().equals(Descripcion)) {
            miTipoDeServicioRetorno=unTipoDeServicio;
        }
    }
    return miTipoDeServicioRetorno;
}
public void editarTipoDeServicio(int codigo, String descripcion) throws PreexistingEntityException, Exception{
    TipoDeServicio miTipoDeServicio=this.dameMiTipoDeServicio(codigo);
    miTipoDeServicio.setDescripcion(descripcion);
    this.miPersistencia.agregarTipoDeServicio(miTipoDeServicio);
}
public List<TipoDeServicio> dameMisTiposDeServicios(){
    return this.misTiposDeServicios;
}
////////// CLASE TIPO PEDIDO
public void agregarTipoPedido(int codigo, String descripcion) throws PreexistingEntityException, PreexistingEntityException, Exception{
    TipoPedido miTipoPedido = new TipoPedido(codigo, descripcion);
    this.misTiposPedidos.add(miTipoPedido);
    miPersistencia.agregarTipoPedido(miTipoPedido);
}
public TipoPedido dameMiTipoPedido(int codigo){
    TipoPedido miTipoPedidoRetorno=null;
    for(TipoPedido unTipoPedido:this.misTiposPedidos){
        if(unTipoPedido.getCodigo()==codigo){
            miTipoPedidoRetorno=unTipoPedido;
        }
    }
    return miTipoPedidoRetorno;
}
public void editarTipoPedido(int codigo, String descripcion) throws PreexistingEntityException, Exception{
    TipoPedido miTipoPedido=this.dameMiTipoPedido(codigo);
    miTipoPedido.setDescripcion(descripcion);
    this.miPersistencia.agregarTipoPedido(miTipoPedido);
}
public List<TipoPedido> dameMisTiposPedidos(){
    return this.misTiposPedidos;
}
////////// CLASE TURNO
public void agregarTurno(int Codigo, Calendar fecha, Calendar hora, Calendar duracion, Tecnico miTecnico, Cliente miCliente, Taller miTaller, List<Servicio> misServicios, OrdenDeReparacion miOrden, Vehiculo miVehiculo) throws PreexistingEntityException, Exception{
    Turno miTurno = new Turno(Codigo, fecha, hora, duracion, miTecnico, miCliente, miTaller, misServicios, miOrden, miVehiculo);
    this.misTurnos.add(miTurno);
    miPersistencia.agregarTurno(miTurno);
}
public Turno dameMiTurno(int Codigo){
    Turno miTurnoRetorno=null;
    for(Turno unTurno:this.misTurnos){
        if(unTurno.getCodigo()==Codigo){
            miTurnoRetorno=unTurno;
        }
    }
    return miTurnoRetorno;
}
public void editarTurno(int Codigo, Calendar fecha, Calendar hora, Calendar duracion, Tecnico miTecnico, Cliente miCliente, Taller miTaller, List<Servicio> misServicios, OrdenDeReparacion miOrden, Vehiculo miVehiculo) throws PreexistingEntityException, Exception{
    Turno miTurno=this.dameMiTurno(Codigo);
    miTurno.setDuracion(duracion);
    miTurno.setFecha(fecha);
    miTurno.setHora(hora);
    miTurno.setMiCliente(miCliente);
    miTurno.setMiOrden(miOrden);
    miTurno.setMiTaller(miTaller);
    miTurno.setMiTecnico(miTecnico);
    miTurno.setMiVehiculo(miVehiculo);
    miTurno.setMisServicios(misServicios);
    this.miPersistencia.agregarTurno(miTurno);
}
public void EditarTurno(Turno miTurno) throws NonexistentEntityException, Exception{
    this.miPersistencia.editar(miTurno);
}
public List<Turno> dameMisTurnos(){
    return this.misTurnos;
}
////////// CLASE VEHICULO
public void agregarVehiculo(String numeroPatente, String numeroMotor, String numeroChasis, Modelo miModelo, Marca miMarca, Segmento miSegmento) throws PreexistingEntityException, Exception{
     List<Egreso> misEgresos=new LinkedList();
     List<Ingreso> misIngresos=new LinkedList();
     List<InformeDeDiagnostico> misInformes=new LinkedList();
     List<Turno> misTurnos=new LinkedList();
     List<GrupoDeConstruccion> misGrupos=new LinkedList();
    Vehiculo miVehiculo = new Vehiculo(numeroPatente, numeroMotor, numeroChasis, miModelo, miMarca, miSegmento, misEgresos, misIngresos, misInformes, misTurnos, misGrupos);
    this.misVehiculos.add(miVehiculo);
    miPersistencia.agregarVehiculo(miVehiculo);
}
public Vehiculo dameMiVehiculo(String numeroPatente){
    Vehiculo miVehiculoRetorno=null;
    for(Vehiculo unVehiculo:this.misVehiculos){
        if(unVehiculo.getNumeroPatente().equals(numeroPatente)){
            miVehiculoRetorno=unVehiculo;
        }
    }
    return miVehiculoRetorno;
}
public Vehiculo buscarVehiculoNombre(String Nombre){
    Vehiculo miVehiculo=null;
    
    for (Vehiculo unVehiculo:this.misVehiculos){
        if (unVehiculo.getMiModelo().getDescripcion().equals(Nombre)){
            miVehiculo=unVehiculo;
        }
    }
    return miVehiculo;
}
public void editarVehiculo(String numeroPatente, String numeroMotor, String numeroChasis, Modelo miModelo, Marca miMarca, Segmento miSegmento, List<Egreso> misEgresos, List<Ingreso> misIngresos, List<InformeDeDiagnostico> misInformes, List<Turno> misTurnos, List<GrupoDeConstruccion> misGrupos) throws PreexistingEntityException, Exception{
    Vehiculo miVehiculo=this.dameMiVehiculo(numeroPatente);
    miVehiculo.setNumeroMotor(numeroMotor);
    miVehiculo.setNumeroChasis(numeroChasis);
    miVehiculo.setMiModelo(miModelo);
    miVehiculo.setMiMarca(miMarca);
    miVehiculo.setMiSegmento(miSegmento);
    miVehiculo.setMisEgresos(misEgresos);
    miVehiculo.setMisGrupos(misGrupos);
    miVehiculo.setMisInformes(misInformes);
    miVehiculo.setMisTurnos(misTurnos);
    miVehiculo.setMisIngresos(misIngresos);
    miVehiculo.setNumeroPatente(numeroPatente);
    this.miPersistencia.agregarVehiculo(miVehiculo);
}
public List<Vehiculo> dameMisVehiculos(){
    return this.misVehiculos;
}
////////// CLASE ZONAS
public void agregarZona(int codigo, String nombreZona, List<Calle> misCalles, Sucursal miSucursal, Localidad miLocalidad) throws PreexistingEntityException, Exception{
Zona miZona = new Zona(codigo, nombreZona, misCalles, miSucursal, miLocalidad);
this.misZonas.add(miZona);
miPersistencia.agregarZona(miZona);
}
public Zona dameMiZona(int codigo){
    Zona miZonaRetorno=null;
    for(Zona unaZona:this.misZonas){
        if(unaZona.getCodigo()==codigo){
            miZonaRetorno=unaZona;
        }
    }
    return miZonaRetorno;
}
public void editarZona(int codigo, String nombreZona, List<Calle> misCalles, Sucursal miSucursal, Localidad miLocalidad) throws PreexistingEntityException, Exception{
Zona miZona = this.dameMiZona(codigo);
miZona.setMiLocalidad(miLocalidad);
miZona.setMiSucursal(miSucursal);
miZona.setMisCalles(misCalles);
miZona.setNombreZona(nombreZona);
this.miPersistencia.agregarZona(miZona);
} 
public Zona buscarZona(String nombreZona){
    Zona miZona=null;
    
    for (Zona unaZona:this.misZonas){
        if (unaZona.getNombreZona().equals(nombreZona)){
            miZona=unaZona;
        }
    }
    return miZona;
}
public List<Zona> dameMisZonas(){
    return this.misZonas;
}
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
    MenuPrincipal miMenu= new MenuPrincipal();
    miMenu.show();
    }
    }
